home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume2 / languags / cdecl.2 < prev    next >
Text File  |  1988-11-05  |  60KB  |  2,591 lines
  1. Path: wucfua!wucs1!uunet!husc6!bbn!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v02i055:  cdecl - C & C++ declaration composer/decoder, Part02/03
  5. Message-ID: <10054@swan.ulowell.edu>
  6. Date: 4 Nov 88 23:10:28 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 2580
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: finkel@taurus.bitnet (Udi Finkelstein)
  12. Posting-number: Volume 2, Issue 55
  13. Archive-name: languages/cdecl.2
  14.  
  15. #    This is a shell archive.
  16. #    Remove everything above and including the cut line.
  17. #    Then run the rest of the file through sh.
  18. #----cut here-----cut here-----cut here-----cut here----#
  19. #!/bin/sh
  20. # shar:    Shell Archiver
  21. #    Run the following text with /bin/sh to create:
  22. #    cdgram.c
  23. #    cdlex.c
  24. #    cdecl.notes
  25. # This archive created: Fri Nov  4 18:01:31 1988
  26. cat << \SHAR_EOF > cdgram.c
  27.  
  28. /* Yacc grammar for ANSI and C++ cdecl. */
  29. /* The output of this file is included */
  30. /* into the C file cdecl.c. */
  31. char cdgramsccsid[] = "@(#)cdgram.y    2.2 3/30/88";
  32.  
  33. typedef union  {
  34.     char *dynstr;
  35.     struct {
  36.         char *left;
  37.         char *right;
  38.         char *type;
  39.     } halves;
  40. } YYSTYPE;
  41. # define ARRAY 257
  42. # define AS 258
  43. # define CAST 259
  44. # define COMMA 260
  45. # define DECLARE 261
  46. # define DOUBLECOLON 262
  47. # define EXPLAIN 263
  48. # define FUNCTION 264
  49. # define HELP 265
  50. # define INTO 266
  51. # define OF 267
  52. # define MEMBER 268
  53. # define POINTER 269
  54. # define REFERENCE 270
  55. # define RETURNING 271
  56. # define SET 272
  57. # define TO 273
  58. # define CHAR 274
  59. # define CLASS 275
  60. # define CONSTVOLATILE 276
  61. # define DOUBLE 277
  62. # define ENUM 278
  63. # define FLOAT 279
  64. # define INT 280
  65. # define LONG 281
  66. # define NAME 282
  67. # define NUMBER 283
  68. # define SHORT 284
  69. # define SIGNED 285
  70. # define STRUCT 286
  71. # define UNION 287
  72. # define UNSIGNED 288
  73. # define VOID 289
  74. # define AUTO 290
  75. # define EXTERN 291
  76. # define REGISTER 292
  77. # define STATIC 293
  78. #define yyclearin yychar = -1
  79. #define yyerrok yyerrflag = 0
  80. extern int yychar;
  81. extern short yyerrflag;
  82. #ifndef YYMAXDEPTH
  83. #define YYMAXDEPTH 150
  84. #endif
  85. YYSTYPE yylval, yyval;
  86. # define YYERRCODE 256
  87.  
  88.  
  89. short yyexca[] ={
  90. -1, 1,
  91.     0, -1,
  92.     -2, 0,
  93. -1, 27,
  94.     282, 81,
  95.     40, 81,
  96.     42, 81,
  97.     38, 81,
  98.     -2, 87,
  99. -1, 37,
  100.     260, 31,
  101.     41, 31,
  102.     -2, 81,
  103. -1, 87,
  104.     282, 82,
  105.     40, 82,
  106.     42, 82,
  107.     38, 82,
  108.     -2, 80,
  109. -1, 92,
  110.     260, 31,
  111.     41, 31,
  112.     -2, 81,
  113.     };
  114. # define YYNPROD 89
  115. # define YYLAST 322
  116. short yyact[]={
  117.  
  118.   67,  79,  28,  69,  72,  68,  66,  76, 159,  13,
  119.   77,  75,  78,  73,  74,  70,  79,  16,  17,  18,
  120.   19,  16,  17,  18,  19,  67, 129,  78,  69, 103,
  121.   68,  66, 125,  25,  76,  39,  23,  77,  75, 128,
  122.   70,  74, 118,  22, 115, 137, 117, 118,  85, 115,
  123.   86, 117,  83,  23, 152,  25,  30, 100,  23,  10,
  124.   22,  56,  25,  23,  47,  22,  60,  59,  37,  97,
  125.   22, 121,  25,  40,  41, 123,  58,  25,  20,  34,
  126.  139, 110,  25, 161, 144,  93, 145,  92,  94,  32,
  127.   24,  57, 147,  71, 126,  29,  81,  21,  42,  55,
  128.    8, 136, 108, 150,  12, 135,  33, 106,  11, 114,
  129.   31,  10,  62, 151, 132, 134,  44,  45,  48,  49,
  130.  156,  43,  35,   2,  63,  15,  53,   1,  54,  14,
  131.   50,  64,  27,  65,  52, 101,  26,  46,  87,  82,
  132.   61,  38,   0,  90,  80,  88,   0,   0,  89,   0,
  133.   95,  96,  98, 108,  91, 108,   0,   0, 108,   0,
  134.   11,   0,  51,   0,   0,   0,   0,   0,   0,   0,
  135.    0,   0,   0,   0, 109,   0, 111, 104, 102,   0,
  136.    0,   0, 105, 112, 107,   0, 122,  99,   0, 113,
  137.    0, 119, 120,   0,   0,   0,   0, 127,   0,   0,
  138.    0,   0,   0,   0,   0, 124, 131,   0, 133,   0,
  139.    0,   0,   0, 142,   0,   0, 130, 143,   0,   0,
  140.    0,   0,   0,   0,   0, 138, 146, 140, 141, 148,
  141.    0, 149,   0,   0,   0,   0, 127,   0,   0,   0,
  142.  153,   0,   0,  25, 158,   0,   0, 127,   0, 128,
  143.  155, 160,  16,  17,  18,  19, 154,   0,   0,   0,
  144.    0, 157,   0,   0,   0,   0,   0,  25,   0,   0,
  145.    0,   0,   0, 128,   0,   0,   0,   0,   0,   0,
  146.    0,   0,   0,   0,   0,   0, 116,   0,   0,   0,
  147.    0, 116,  84,   0,   0,   0,   0,   0,   0,  36,
  148.    0,   0, 145, 145,  92,   9,   0,   0,   5,   0,
  149.    4,   0,   6,   0,   3,   0,   0,   0,   0,   0,
  150.    0,   7 };
  151. short yypact[]={
  152.  
  153. -1000,  49,-1000, 101,-273,-204, -38,-226,-1000, 101,
  154. -1000,-1000,-1000,-169,-194,-1000,-1000,-1000,-1000,-1000,
  155. -187, 101,  28,-248,-196,-214,-212,-214,-214, 101,
  156. -1000,-1000,-269, 101,-194,-1000,-194,-221,-191,-1000,
  157. -206,-207,-1000,-274,-1000,-1000,  10,-214,  10,-1000,
  158. -1000,-194,-1000, 101,-1000,  44,-170,-1000,-194,-199,
  159. -194,-1000,-249,-1000,-225,-247,-1000,-1000,-1000,-1000,
  160. -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
  161.   10, 101,  67,-214,-181,-214,  10,-1000, 101,   9,
  162.  101,-1000,-221,-200,-194,-1000,-1000,-192,-1000,-1000,
  163. -1000,-1000,-1000,-1000, 101,-1000,  -9,-1000, -67,  10,
  164.   72,  10,  74,-1000,  64,   4,-182,   9,   9,-1000,
  165. -173,-194,-1000,-259,-1000,-1000,  43,-1000,-1000,-1000,
  166.   -1,-1000,  10,-1000,-1000,-226,-1000,-1000,  62,  71,
  167.   11,  11,-1000,-228,-1000,-243,   9,-1000,-1000, 101,
  168.   80,   9,-194,-174,  11,-1000, -33,  11,-1000,-1000,
  169.   42,-1000 };
  170. short yypgo[]={
  171.  
  172.    0,  99, 141, 140, 109,  94,  96, 139, 101, 137,
  173.   93, 112, 135, 133,  90,  95, 129, 125, 131, 124,
  174.   98,  91, 127, 123, 100, 121 };
  175. short yyr1[]={
  176.  
  177.    0,  22,  22,  23,  23,  23,  23,  23,  23,  23,
  178.   23,  23,  23,  23,  23,  24,  24,  15,  15,   6,
  179.    6,   6,   6,   7,   7,   7,   7,   7,   5,   5,
  180.    5,   1,   1,   1,   1,   1,   4,   4,   4,   4,
  181.    4,   4,   4,   4,   4,   8,   8,  21,  21,  21,
  182.   21,  21,  21,  21,   2,   2,  20,  25,   3,   3,
  183.    3,   3,  18,  18,  18,  10,  10,  19,  19,  19,
  184.   19,  19,  11,  11,  12,  12,  13,  13,  13,  13,
  185.   14,  14,   9,  17,  17,  17,  17,  16,  16 };
  186. short yyr2[]={
  187.  
  188.    0,   0,   2,   2,   6,   4,   5,   3,   6,   5,
  189.    5,   8,   3,   1,   2,   1,   1,   1,   0,   1,
  190.    3,   4,   3,   3,   4,   2,   3,   1,   3,   3,
  191.    1,   0,   3,   1,   1,   3,   0,   2,   5,   6,
  192.    3,   4,   2,   2,   2,   2,   3,   3,   6,   4,
  193.    4,   8,   4,   2,   0,   1,   2,   0,   1,   1,
  194.    2,   2,   1,   1,   1,   1,   1,   1,   1,   1,
  195.    1,   1,   2,   1,   1,   1,   1,   1,   1,   1,
  196.    2,   0,   2,   1,   1,   1,   1,   1,   0 };
  197. short yychk[]={
  198.  
  199. -1000, -22, -23, 265, 261, 259, 263, 272, -24, 256,
  200.   10,  59, -24, 282, -16, -17, 290, 291, 292, 293,
  201.  282, -21, 264, 257, -14, 276, -16, -17,  40, -15,
  202.  282, -24, 258, -21, 266, -24, 271,  40,  -2, 283,
  203.  269, 270, -20, -25, -14, -14,  -9, 276, -14, -14,
  204.  -24, -16, -24, -21, -21,  -1, 282, -21, 267, 273,
  205.  273,  -3, -11, -19, -18, -13, 280, 274, 279, 277,
  206.  289, -10, 278, 287, 288, 285, 281, 284, 286, 275,
  207.  -20,  -6,  -7,  42, 282,  38,  40, -14,  -6, -20,
  208.  -21, -24, 260,  41, 258, -21, -21, 268, -21, -19,
  209.  282, -12, -11, 276,  -6, -24,  40,  -8,  91, -14,
  210.  262, -14,  -6, -24,  -4,  40, 282,  42,  38, -24,
  211.   -1, 271, -21, 267, -24,  41,  -5, -14, 282,  93,
  212.  283,  -6,  42,  -6,  41,  41,  -8,  41,  -4, 262,
  213.   -4,  -4, -21, -10,  41, 260, -20,  93,  -6, -15,
  214.   41,  42, 282,  -5,  -4, -24,  40,  -4, -21,  41,
  215.   -5,  41 };
  216. short yydef[]={
  217.  
  218.    1,  -2,   2,   0,  88,  81,  88,  18,  13,   0,
  219.   15,  16,   3,   0,  81,  87,  83,  84,  85,  86,
  220.    0,   0,   0,  54,  57,  81,  81,  -2,  81,   0,
  221.   17,  14,  88,   0,  81,   7,  81,  -2,   0,  55,
  222.    0,   0,  53,   0,  80,  57,   0,  81,   0,  57,
  223.   12,  81,   5,   0,  47,   0,  33,  34,  81,  81,
  224.   81,  56,  58,  59,   0,  73,  67,  68,  69,  70,
  225.   71,  62,  63,  64,  76,  77,  78,  79,  65,  66,
  226.    0,   0,  19,  81,  27,  81,   0,  -2,   0,  36,
  227.    0,   6,  -2,   0,  81,  49,  50,   0,  52,  60,
  228.   61,  72,  74,  75,   0,  10,  81,  25,   0,   0,
  229.    0,   0,   0,   9,   0,  36,   0,  36,  36,   4,
  230.   32,  81,  35,   0,   8,  23,   0,  57,  30,  45,
  231.    0,  20,   0,  22,  26,  18,  44,  37,   0,   0,
  232.   42,  43,  48,   0,  24,  81,  36,  46,  21,   0,
  233.   40,  36,  81,  28,  29,  11,  81,  41,  51,  38,
  234.    0,  39 };
  235. #ifndef lint
  236. static    char yaccpar_sccsid[] = "@(#)yaccpar 1.2 86/07/18 SMI"; /* from UCB 4.1 83/02/11 */
  237. #endif
  238.  
  239. #
  240. # define YYFLAG -1000
  241. # define YYERROR goto yyerrlab
  242. # define YYACCEPT return(0)
  243. # define YYABORT return(1)
  244.  
  245. /*    parser for yacc output    */
  246.  
  247. #ifdef YYDEBUG
  248. int yydebug = 0; /* 1 for debugging */
  249. #endif
  250. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  251. int yychar = -1; /* current input token number */
  252. int yynerrs = 0;  /* number of errors */
  253. short yyerrflag = 0;  /* error recovery flag */
  254.  
  255. yyparse() {
  256.  
  257.     short yys[YYMAXDEPTH];
  258.     short yyj, yym;
  259.     register YYSTYPE *yypvt;
  260.     register short yystate, *yyps, yyn;
  261.     register YYSTYPE *yypv;
  262.     register short *yyxi;
  263.  
  264.     yystate = 0;
  265.     yychar = -1;
  266.     yynerrs = 0;
  267.     yyerrflag = 0;
  268.     yyps= &yys[-1];
  269.     yypv= &yyv[-1];
  270.  
  271.  yystack:    /* put a state and value onto the stack */
  272.  
  273. #ifdef YYDEBUG
  274.     if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  275. #endif
  276.         if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
  277.         *yyps = yystate;
  278.         ++yypv;
  279.         *yypv = yyval;
  280.  
  281.  yynewstate:
  282.  
  283.     yyn = yypact[yystate];
  284.  
  285.     if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  286.  
  287.     if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  288.     if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  289.  
  290.     if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  291.         yychar = -1;
  292.         yyval = yylval;
  293.         yystate = yyn;
  294.         if( yyerrflag > 0 ) --yyerrflag;
  295.         goto yystack;
  296.         }
  297.  
  298.  yydefault:
  299.     /* default state action */
  300.  
  301.     if( (yyn=yydef[yystate]) == -2 ) {
  302.         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  303.         /* look through exception table */
  304.  
  305.         for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  306.  
  307.         while( *(yyxi+=2) >= 0 ){
  308.             if( *yyxi == yychar ) break;
  309.             }
  310.         if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  311.         }
  312.  
  313.     if( yyn == 0 ){ /* error */
  314.         /* error ... attempt to resume parsing */
  315.  
  316.         switch( yyerrflag ){
  317.  
  318.         case 0:   /* brand new error */
  319.  
  320.             yyerror( "syntax error" );
  321.         yyerrlab:
  322.             ++yynerrs;
  323.  
  324.         case 1:
  325.         case 2: /* incompletely recovered error ... try again */
  326.  
  327.             yyerrflag = 3;
  328.  
  329.             /* find a state where "error" is a legal shift action */
  330.  
  331.             while ( yyps >= yys ) {
  332.                yyn = yypact[*yyps] + YYERRCODE;
  333.                if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
  334.                   yystate = yyact[yyn];  /* simulate a shift of "error" */
  335.                   goto yystack;
  336.                   }
  337.                yyn = yypact[*yyps];
  338.  
  339.                /* the current yyps has no shift onn "error", pop stack */
  340.  
  341. #ifdef YYDEBUG
  342.                if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  343. #endif
  344.                --yyps;
  345.                --yypv;
  346.                }
  347.  
  348.             /* there is no state on the stack with an error shift ... abort */
  349.  
  350.     yyabort:
  351.             return(1);
  352.  
  353.  
  354.         case 3:  /* no shift yet; clobber input char */
  355.  
  356. #ifdef YYDEBUG
  357.             if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  358. #endif
  359.  
  360.             if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  361.             yychar = -1;
  362.             goto yynewstate;   /* try again in the same state */
  363.  
  364.             }
  365.  
  366.         }
  367.  
  368.     /* reduction by production yyn */
  369.  
  370. #ifdef YYDEBUG
  371.         if( yydebug ) printf("reduce %d\n",yyn);
  372. #endif
  373.         yyps -= yyr2[yyn];
  374.         yypvt = yypv;
  375.         yypv -= yyr2[yyn];
  376.         yyval = yypv[1];
  377.         yym=yyn;
  378.             /* consult goto table to find next state */
  379.         yyn = yyr1[yyn];
  380.         yyj = yypgo[yyn] + *yyps + 1;
  381.         if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  382.         switch(yym){
  383.             
  384. case 2:
  385. {
  386.             prompt();
  387.             prev = 0;
  388.             } break;
  389. case 3:
  390. {
  391.             Debug((stderr, "stmt: help\n"));
  392.             dohelp();
  393.             } break;
  394. case 4:
  395. {
  396.             Debug((stderr, "stmt: DECLARE NAME AS opt_storage adecl\n"));
  397.             Debug((stderr, "\tNAME='%s'\n", yypvt[-4].dynstr));
  398.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-2].dynstr));
  399.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  400.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  401.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  402.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  403.             dodeclare(yypvt[-4].dynstr, yypvt[-2].dynstr, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  404.             } break;
  405. case 5:
  406. {
  407.             Debug((stderr, "stmt: DECLARE opt_storage adecl\n"));
  408.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-2].dynstr));
  409.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  410.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  411.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  412.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  413.             dodeclare(NullCP, yypvt[-2].dynstr, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  414.             } break;
  415. case 6:
  416. {
  417.             Debug((stderr, "stmt: CAST NAME AS adecl\n"));
  418.             Debug((stderr, "\tNAME='%s'\n", yypvt[-3].dynstr));
  419.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  420.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  421.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  422.             docast(yypvt[-3].dynstr, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  423.             } break;
  424. case 7:
  425. {
  426.             Debug((stderr, "stmt: CAST adecl\n"));
  427.             Debug((stderr, "\tacdecl.left='%s'\n", yypvt[-1].halves.left));
  428.             Debug((stderr, "\tacdecl.right='%s'\n", yypvt[-1].halves.right));
  429.             Debug((stderr, "\tacdecl.type='%s'\n", yypvt[-1].halves.type));
  430.             docast(NullCP, yypvt[-1].halves.left, yypvt[-1].halves.right, yypvt[-1].halves.type);
  431.             } break;
  432. case 8:
  433. {
  434.             Debug((stderr, "stmt: EXPLAIN opt_storage opt_constvol_list type cdecl\n"));
  435.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-4].dynstr));
  436.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-3].dynstr));
  437.             Debug((stderr, "\ttype='%s'\n", yypvt[-2].dynstr));
  438.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  439.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  440.             dodexplain(yypvt[-4].dynstr, yypvt[-3].dynstr, yypvt[-2].dynstr, yypvt[-1].dynstr);
  441.             } break;
  442. case 9:
  443. {
  444.             Debug((stderr, "stmt: EXPLAIN storage opt_constvol_list cdecl\n"));
  445.             Debug((stderr, "\tstorage='%s'\n", yypvt[-3].dynstr));
  446.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-2].dynstr));
  447.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  448.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  449.             dodexplain(yypvt[-3].dynstr, yypvt[-2].dynstr, NullCP, yypvt[-1].dynstr);
  450.             } break;
  451. case 10:
  452. {
  453.             Debug((stderr, "stmt: EXPLAIN opt_storage constvol_list cdecl\n"));
  454.             Debug((stderr, "\topt_storage='%s'\n", yypvt[-3].dynstr));
  455.             Debug((stderr, "\tconstvol_list='%s'\n", yypvt[-2].dynstr));
  456.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  457.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  458.             dodexplain(yypvt[-3].dynstr, yypvt[-2].dynstr, NullCP, yypvt[-1].dynstr);
  459.             } break;
  460. case 11:
  461. {
  462.             Debug((stderr, "stmt: EXPLAIN ( opt_constvol_list type cast ) optNAME\n"));
  463.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-5].dynstr));
  464.             Debug((stderr, "\ttype='%s'\n", yypvt[-4].dynstr));
  465.             Debug((stderr, "\tcast='%s'\n", yypvt[-3].dynstr));
  466.             Debug((stderr, "\tNAME='%s'\n", yypvt[-1].dynstr));
  467.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  468.             docexplain(yypvt[-5].dynstr, yypvt[-4].dynstr, yypvt[-3].dynstr, yypvt[-1].dynstr);
  469.             } break;
  470. case 12:
  471. {
  472.             Debug((stderr, "stmt: SET optNAME\n"));
  473.             Debug((stderr, "\toptNAME='%s'\n", yypvt[-1].dynstr));
  474.             doset(yypvt[-1].dynstr);
  475.             } break;
  476. case 14:
  477. {
  478.             yyerrok;
  479.             } break;
  480. case 15:
  481. {
  482.             doprompt();
  483.             } break;
  484. case 16:
  485. {
  486.             noprompt();
  487.             } break;
  488. case 17:
  489. {
  490.             Debug((stderr, "optNAME: NAME\n"));
  491.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  492.             yyval.dynstr = yypvt[-0].dynstr;
  493.             } break;
  494. case 18:
  495. {
  496.             Debug((stderr, "optNAME: EMPTY\n"));
  497.             yyval.dynstr = ds(unknown_name);
  498.             } break;
  499. case 20:
  500. {
  501.             Debug((stderr, "cdecl: * opt_constvol_list cdecl\n"));
  502.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-1].dynstr));
  503.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-0].dynstr));
  504.             yyval.dynstr = cat(yypvt[-0].dynstr,yypvt[-1].dynstr,ds(strlen(yypvt[-1].dynstr)?" pointer to ":"pointer to "),NullCP);
  505.             prev = 'p';
  506.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  507.             } break;
  508. case 21:
  509. {
  510.             Debug((stderr, "cdecl: NAME DOUBLECOLON '*' cdecl\n"));
  511.             Debug((stderr, "\tNAME='%s'\n", yypvt[-3].dynstr));
  512.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-0].dynstr));
  513.             if (!CplusplusFlag)
  514.                 unsupp("pointer to member of class", NullCP);
  515.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("pointer to member of class "),yypvt[-3].dynstr,ds(" "),NullCP);
  516.             prev = 'p';
  517.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  518.             } break;
  519. case 22:
  520. {
  521.             Debug((stderr, "cdecl: & opt_constvol_list cdecl\n"));
  522.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-1].dynstr));
  523.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-0].dynstr));
  524.             if (!CplusplusFlag)
  525.                 unsupp("reference", NullCP);
  526.             yyval.dynstr = cat(yypvt[-0].dynstr,yypvt[-1].dynstr,ds(strlen(yypvt[-1].dynstr)?" reference to ":"reference to "),NullCP);
  527.             prev = 'r';
  528.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  529.             } break;
  530. case 23:
  531. {
  532.             Debug((stderr, "cdecl1: cdecl1()\n"));
  533.             Debug((stderr, "\tcdecl1='%s'\n", yypvt[-2].dynstr));
  534.             yyval.dynstr = cat(yypvt[-2].dynstr,ds("function returning "),NullCP);
  535.             prev = 'f';
  536.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  537.             } break;
  538. case 24:
  539. {
  540.             Debug((stderr, "cdecl1: cdecl1(castlist)\n"));
  541.             Debug((stderr, "\tcdecl1='%s'\n", yypvt[-3].dynstr));
  542.             Debug((stderr, "\tcastlist='%s'\n", yypvt[-1].dynstr));
  543.             yyval.dynstr = cat(yypvt[-3].dynstr, ds("function ("),
  544.                   yypvt[-1].dynstr, ds(") returning "), NullCP);
  545.             prev = 'f';
  546.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  547.             } break;
  548. case 25:
  549. {
  550.             Debug((stderr, "cdecl1: cdecl1 cdims\n"));
  551.             Debug((stderr, "\tcdecl1='%s'\n", yypvt[-1].dynstr));
  552.             Debug((stderr, "\tcdims='%s'\n", yypvt[-0].dynstr));
  553.             yyval.dynstr = cat(yypvt[-1].dynstr,ds("array "),yypvt[-0].dynstr,NullCP);
  554.             prev = 'a';
  555.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  556.             } break;
  557. case 26:
  558. {
  559.             Debug((stderr, "cdecl1: (cdecl)\n"));
  560.             Debug((stderr, "\tcdecl='%s'\n", yypvt[-1].dynstr));
  561.             yyval.dynstr = yypvt[-1].dynstr;
  562.             /* prev = prev; */
  563.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  564.             } break;
  565. case 27:
  566. {
  567.             Debug((stderr, "cdecl1: NAME\n"));
  568.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  569.             savedname = yypvt[-0].dynstr;
  570.             yyval.dynstr = ds("");
  571.             prev = 'n';
  572.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  573.             } break;
  574. case 28:
  575. {
  576.             Debug((stderr, "castlist: castlist1, castlist2\n"));
  577.             Debug((stderr, "\tcastlist1='%s'\n", yypvt[-2].dynstr));
  578.             Debug((stderr, "\tcastlist2='%s'\n", yypvt[-0].dynstr));
  579.             yyval.dynstr = cat(yypvt[-2].dynstr, ds(", "), yypvt[-0].dynstr, NullCP);
  580.             } break;
  581. case 29:
  582. {
  583.             Debug((stderr, "castlist: opt_constvol_list type cast\n"));
  584.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-2].dynstr));
  585.             Debug((stderr, "\ttype='%s'\n", yypvt[-1].dynstr));
  586.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  587.             yyval.dynstr = cat(yypvt[-0].dynstr, yypvt[-2].dynstr, ds(strlen(yypvt[-2].dynstr) ? " " : ""), yypvt[-1].dynstr, NullCP);
  588.             } break;
  589. case 30:
  590. {
  591.             yyval.dynstr = yypvt[-0].dynstr;
  592.             } break;
  593. case 31:
  594. {
  595.             Debug((stderr, "adecllist: EMPTY\n"));
  596.             yyval.dynstr = ds("");
  597.             } break;
  598. case 32:
  599. {
  600.             Debug((stderr, "adecllist: adecllist1, adecllist2\n"));
  601.             Debug((stderr, "\tadecllist1='%s'\n", yypvt[-2].dynstr));
  602.             Debug((stderr, "\tadecllist2='%s'\n", yypvt[-0].dynstr));
  603.             yyval.dynstr = cat(yypvt[-2].dynstr, ds(", "), yypvt[-0].dynstr, NullCP);
  604.             } break;
  605. case 33:
  606. {
  607.             Debug((stderr, "adecllist: NAME\n"));
  608.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  609.             yyval.dynstr = yypvt[-0].dynstr;
  610.             } break;
  611. case 34:
  612. {
  613.             Debug((stderr, "adecllist: adecl\n"));
  614.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  615.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  616.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  617.             yyval.dynstr = cat(yypvt[-0].halves.type, ds(" "), yypvt[-0].halves.left, yypvt[-0].halves.right, NullCP);
  618.             } break;
  619. case 35:
  620. {
  621.             Debug((stderr, "adecllist: NAME AS adecl\n"));
  622.             Debug((stderr, "\tNAME='%s'\n", yypvt[-2].dynstr));
  623.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  624.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  625.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  626.             yyval.dynstr = cat(yypvt[-0].halves.type, ds(" "), yypvt[-0].halves.left, yypvt[-2].dynstr, yypvt[-0].halves.right, NullCP);
  627.             } break;
  628. case 36:
  629. {
  630.             Debug((stderr, "cast: EMPTY\n"));
  631.             yyval.dynstr = ds("");
  632.             /* prev = prev; */
  633.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  634.             } break;
  635. case 37:
  636. {
  637.             Debug((stderr, "cast: ()\n"));
  638.             yyval.dynstr = ds("function returning ");
  639.             prev = 'f';
  640.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  641.             } break;
  642. case 38:
  643. {
  644.             Debug((stderr, "cast: (cast)()\n"));
  645.             Debug((stderr, "\tcast='%s'\n", yypvt[-3].dynstr));
  646.             yyval.dynstr = cat(yypvt[-3].dynstr,ds("function returning "),NullCP);
  647.             prev = 'f';
  648.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  649.             } break;
  650. case 39:
  651. {
  652.             Debug((stderr, "cast: (cast)(castlist)\n"));
  653.             Debug((stderr, "\tcast='%s'\n", yypvt[-4].dynstr));
  654.             Debug((stderr, "\tcastlist='%s'\n", yypvt[-1].dynstr));
  655.             yyval.dynstr = cat(yypvt[-4].dynstr,ds("function ("),yypvt[-1].dynstr,ds(") returning "),NullCP);
  656.             prev = 'f';
  657.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  658.             } break;
  659. case 40:
  660. {
  661.             Debug((stderr, "cast: (cast)\n"));
  662.             Debug((stderr, "\tcast='%s'\n", yypvt[-1].dynstr));
  663.             yyval.dynstr = yypvt[-1].dynstr;
  664.             /* prev = prev; */
  665.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  666.             } break;
  667. case 41:
  668. {
  669.             Debug((stderr, "cast: NAME::*cast\n"));
  670.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  671.             if (!CplusplusFlag)
  672.                 unsupp("pointer to member of class", NullCP);
  673.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("pointer to member of class "),yypvt[-3].dynstr,ds(" "),NullCP);
  674.             prev = 'p';
  675.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  676.             } break;
  677. case 42:
  678. {
  679.             Debug((stderr, "cast: *cast\n"));
  680.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  681.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("pointer to "),NullCP);
  682.             prev = 'p';
  683.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  684.             } break;
  685. case 43:
  686. {
  687.             Debug((stderr, "cast: &cast\n"));
  688.             Debug((stderr, "\tcast='%s'\n", yypvt[-0].dynstr));
  689.             if (!CplusplusFlag)
  690.                 unsupp("reference", NullCP);
  691.             yyval.dynstr = cat(yypvt[-0].dynstr,ds("reference to "),NullCP);
  692.             prev = 'r';
  693.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  694.             } break;
  695. case 44:
  696. {
  697.             Debug((stderr, "cast: cast cdims\n"));
  698.             Debug((stderr, "\tcast='%s'\n", yypvt[-1].dynstr));
  699.             Debug((stderr, "\tcdims='%s'\n", yypvt[-0].dynstr));
  700.             yyval.dynstr = cat(yypvt[-1].dynstr,ds("array "),yypvt[-0].dynstr,NullCP);
  701.             prev = 'a';
  702.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  703.             } break;
  704. case 45:
  705. {
  706.             Debug((stderr, "cdims: []\n"));
  707.             yyval.dynstr = ds("of ");
  708.             } break;
  709. case 46:
  710. {
  711.             Debug((stderr, "cdims: [NUMBER]\n"));
  712.             Debug((stderr, "\tNUMBER='%s'\n", yypvt[-1].dynstr));
  713.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" of "),NullCP);
  714.             } break;
  715. case 47:
  716. {
  717.             Debug((stderr, "adecl: FUNCTION RETURNING adecl\n"));
  718.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  719.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  720.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  721.             if (prev == 'f')
  722.                 unsupp("Function returning function",
  723.                        "function returning pointer to function");
  724.             else if (prev=='A' || prev=='a')
  725.                 unsupp("Function returning array",
  726.                        "function returning pointer");
  727.             yyval.halves.left = yypvt[-0].halves.left;
  728.             yyval.halves.right = cat(ds("()"),yypvt[-0].halves.right,NullCP);
  729.             yyval.halves.type = yypvt[-0].halves.type;
  730.             prev = 'f';
  731.             Debug((stderr, "\n\tadecl now =\n"));
  732.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  733.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  734.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  735.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  736.             } break;
  737. case 48:
  738. {
  739.             Debug((stderr, "adecl: FUNCTION (adecllist) RETURNING adecl\n"));
  740.             Debug((stderr, "\tadecllist='%s'\n", yypvt[-3].dynstr));
  741.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  742.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  743.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  744.             if (prev == 'f')
  745.                 unsupp("Function returning function",
  746.                        "function returning pointer to function");
  747.             else if (prev=='A' || prev=='a')
  748.                 unsupp("Function returning array",
  749.                        "function returning pointer");
  750.             yyval.halves.left = yypvt[-0].halves.left;
  751.             yyval.halves.right = cat(ds("("),yypvt[-3].dynstr,ds(")"),yypvt[-0].halves.right,NullCP);
  752.             yyval.halves.type = yypvt[-0].halves.type;
  753.             prev = 'f';
  754.             Debug((stderr, "\n\tadecl now =\n"));
  755.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  756.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  757.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  758.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  759.             } break;
  760. case 49:
  761. {
  762.             Debug((stderr, "adecl: ARRAY adims OF adecl\n"));
  763.             Debug((stderr, "\tadims='%s'\n", yypvt[-2].dynstr));
  764.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  765.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  766.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  767.             if (prev == 'f')
  768.                 unsupp("Array of function",
  769.                        "array of pointer to function");
  770.             else if (prev == 'a')
  771.                 unsupp("Inner array of unspecified size",
  772.                        "array of pointer");
  773.             else if (prev == 'v')
  774.                 unsupp("Array of void",
  775.                        "pointer to void");
  776.             if (arbdims)
  777.                 prev = 'a';
  778.             else
  779.                 prev = 'A';
  780.             yyval.halves.left = yypvt[-0].halves.left;
  781.             yyval.halves.right = cat(yypvt[-2].dynstr,yypvt[-0].halves.right,NullCP);
  782.             yyval.halves.type = yypvt[-0].halves.type;
  783.             Debug((stderr, "\n\tadecl now =\n"));
  784.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  785.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  786.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  787.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  788.             } break;
  789. case 50:
  790. {
  791.             char *op = "", *cp = "", *sp = "";
  792.  
  793.             Debug((stderr, "adecl: opt_constvol_list POINTER TO adecl\n"));
  794.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-3].dynstr));
  795.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  796.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  797.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  798.             if (prev == 'a')
  799.                 unsupp("Pointer to array of unspecified dimension",
  800.                        "pointer to object");
  801.             if (prev=='a' || prev=='A' || prev=='f') {
  802.                 op = "(";
  803.                 cp = ")";
  804.             }
  805.             if (strlen(yypvt[-3].dynstr) != 0)
  806.                 sp = " ";
  807.             yyval.halves.left = cat(yypvt[-0].halves.left,ds(op),ds("*"),
  808.                        ds(sp),yypvt[-3].dynstr,ds(sp),NullCP);
  809.             yyval.halves.right = cat(ds(cp),yypvt[-0].halves.right,NullCP);
  810.             yyval.halves.type = yypvt[-0].halves.type;
  811.             prev = 'p';
  812.             Debug((stderr, "\n\tadecl now =\n"));
  813.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  814.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  815.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  816.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  817.             } break;
  818. case 51:
  819. {
  820.             char *op = "", *cp = "", *sp = "";
  821.  
  822.             Debug((stderr, "adecl: opt_constvol_list POINTER TO MEMBER OF ClassStruct NAME adecl\n"));
  823.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-7].dynstr));
  824.             Debug((stderr, "\tClassStruct='%s'\n", yypvt[-2].dynstr));
  825.             Debug((stderr, "\tNAME='%s'\n", yypvt[-1].dynstr));
  826.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  827.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  828.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  829.             if (!CplusplusFlag)
  830.                 unsupp("pointer to member of class", NullCP);
  831.             if (prev == 'a')
  832.                 unsupp("Pointer to array of unspecified dimension",
  833.                        "pointer to object");
  834.             if (prev=='a' || prev=='A' || prev=='f') {
  835.                 op = "(";
  836.                 cp = ")";
  837.             }
  838.             if (strlen(yypvt[-7].dynstr) != 0)
  839.                 sp = " ";
  840.             yyval.halves.left = cat(yypvt[-0].halves.left,ds(op),yypvt[-1].dynstr,ds("::*"),
  841.                       ds(sp),yypvt[-7].dynstr,ds(sp),NullCP);
  842.             yyval.halves.right = cat(ds(cp),yypvt[-0].halves.right,NullCP);
  843.             yyval.halves.type = yypvt[-0].halves.type;
  844.             prev = 'p';
  845.             Debug((stderr, "\n\tadecl now =\n"));
  846.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  847.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  848.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  849.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  850.             } break;
  851. case 52:
  852. {
  853.             char *op = "", *cp = "", *sp = "";
  854.  
  855.             Debug((stderr, "adecl: opt_constvol_list REFERENCE TO adecl\n"));
  856.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-3].dynstr));
  857.             Debug((stderr, "\tadecl.left='%s'\n", yypvt[-0].halves.left));
  858.             Debug((stderr, "\tadecl.right='%s'\n", yypvt[-0].halves.right));
  859.             Debug((stderr, "\tadecl.type='%s'\n", yypvt[-0].halves.type));
  860.             if (!CplusplusFlag)
  861.                 unsupp("reference", NullCP);
  862.             if (prev == 'v')
  863.                 unsupp("Reference to void",
  864.                        "pointer to void");
  865.             else if (prev == 'a')
  866.                 unsupp("Reference to array of unspecified dimension",
  867.                        "reference to object");
  868.             if (prev=='a' || prev=='A' || prev=='f') {
  869.                 op = "(";
  870.                 cp = ")";
  871.             }
  872.             if (strlen(yypvt[-3].dynstr) != 0)
  873.                 sp = " ";
  874.             yyval.halves.left = cat(yypvt[-0].halves.left,ds(op),ds("&"),
  875.                        ds(sp),yypvt[-3].dynstr,ds(sp),NullCP);
  876.             yyval.halves.right = cat(ds(cp),yypvt[-0].halves.right,NullCP);
  877.             yyval.halves.type = yypvt[-0].halves.type;
  878.             prev = 'r';
  879.             Debug((stderr, "\n\tadecl now =\n"));
  880.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  881.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  882.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  883.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  884.             } break;
  885. case 53:
  886. {
  887.             Debug((stderr, "adecl: opt_constvol_list type\n"));
  888.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-1].dynstr));
  889.             Debug((stderr, "\ttype='%s'\n", yypvt[-0].dynstr));
  890.             yyval.halves.left = ds("");
  891.             yyval.halves.right = ds("");
  892.             yyval.halves.type = cat(yypvt[-1].dynstr,ds(strlen(yypvt[-1].dynstr)?" ":""),yypvt[-0].dynstr,NullCP);
  893.             if (strcmp(yypvt[-0].dynstr, "void") == 0)
  894.                 prev = 'v';
  895.             else if ((strncmp(yypvt[-0].dynstr, "struct", 6) == 0) ||
  896.                      (strncmp(yypvt[-0].dynstr, "class", 5) == 0))
  897.                 prev = 's';
  898.             else
  899.                 prev = 't';
  900.             Debug((stderr, "\n\tadecl now =\n"));
  901.             Debug((stderr, "\t\tadecl.left='%s'\n", yyval.halves.left));
  902.             Debug((stderr, "\t\tadecl.right='%s'\n", yyval.halves.right));
  903.             Debug((stderr, "\t\tadecl.type='%s'\n", yyval.halves.type));
  904.             Debug((stderr, "\tprev = '%s'\n", visible(prev)));
  905.             } break;
  906. case 54:
  907. {
  908.             Debug((stderr, "adims: EMPTY\n"));
  909.             arbdims = 1;
  910.             yyval.dynstr = ds("[]");
  911.             } break;
  912. case 55:
  913. {
  914.             Debug((stderr, "adims: NUMBER\n"));
  915.             Debug((stderr, "\tNUMBER='%s'\n", yypvt[-0].dynstr));
  916.             arbdims = 0;
  917.             yyval.dynstr = cat(ds("["),yypvt[-0].dynstr,ds("]"),NullCP);
  918.             } break;
  919. case 56:
  920. {
  921.             Debug((stderr, "type: tinit c_type\n"));
  922.             Debug((stderr, "\ttinit=''\n"));
  923.             Debug((stderr, "\tc_type='%s'\n", yypvt[-0].dynstr));
  924.             mbcheck();
  925.             yyval.dynstr = yypvt[-0].dynstr;
  926.             } break;
  927. case 57:
  928. {
  929.             Debug((stderr, "tinit: EMPTY\n"));
  930.             modbits = 0;
  931.             } break;
  932. case 58:
  933. {
  934.             Debug((stderr, "c_type: mod_list\n"));
  935.             Debug((stderr, "\tmod_list='%s'\n", yypvt[-0].dynstr));
  936.             yyval.dynstr = yypvt[-0].dynstr;
  937.             } break;
  938. case 59:
  939. {
  940.             Debug((stderr, "c_type: tname\n"));
  941.             Debug((stderr, "\ttname='%s'\n", yypvt[-0].dynstr));
  942.             yyval.dynstr = yypvt[-0].dynstr;
  943.             } break;
  944. case 60:
  945. {
  946.             Debug((stderr, "c_type: mod_list tname\n"));
  947.             Debug((stderr, "\tmod_list='%s'\n", yypvt[-1].dynstr));
  948.             Debug((stderr, "\ttname='%s'\n", yypvt[-0].dynstr));
  949.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" "),yypvt[-0].dynstr,NullCP);
  950.             } break;
  951. case 61:
  952. {
  953.             Debug((stderr, "c_type: StrClaUniEnum NAME\n"));
  954.             Debug((stderr, "\tStrClaUniEnum='%s'\n", yypvt[-1].dynstr));
  955.             Debug((stderr, "\tNAME='%s'\n", yypvt[-0].dynstr));
  956.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" "),yypvt[-0].dynstr,NullCP);
  957.             } break;
  958. case 64:
  959. {
  960.             yyval.dynstr = yypvt[-0].dynstr;
  961.             } break;
  962. case 66:
  963. {
  964.             yyval.dynstr = yypvt[-0].dynstr;
  965.             } break;
  966. case 67:
  967. {
  968.             Debug((stderr, "tname: INT\n"));
  969.             Debug((stderr, "\tINT='%s'\n", yypvt[-0].dynstr));
  970.             modbits |= MB_INT; yyval.dynstr = yypvt[-0].dynstr;
  971.             } break;
  972. case 68:
  973. {
  974.             Debug((stderr, "tname: CHAR\n"));
  975.             Debug((stderr, "\tCHAR='%s'\n", yypvt[-0].dynstr));
  976.             modbits |= MB_CHAR; yyval.dynstr = yypvt[-0].dynstr;
  977.             } break;
  978. case 69:
  979. {
  980.             Debug((stderr, "tname: FLOAT\n"));
  981.             Debug((stderr, "\tFLOAT='%s'\n", yypvt[-0].dynstr));
  982.             modbits |= MB_FLOAT; yyval.dynstr = yypvt[-0].dynstr;
  983.             } break;
  984. case 70:
  985. {
  986.             Debug((stderr, "tname: DOUBLE\n"));
  987.             Debug((stderr, "\tDOUBLE='%s'\n", yypvt[-0].dynstr));
  988.             modbits |= MB_DOUBLE; yyval.dynstr = yypvt[-0].dynstr;
  989.             } break;
  990. case 71:
  991. {
  992.             Debug((stderr, "tname: VOID\n"));
  993.             Debug((stderr, "\tVOID='%s'\n", yypvt[-0].dynstr));
  994.             modbits |= MB_VOID; yyval.dynstr = yypvt[-0].dynstr;
  995.             } break;
  996. case 72:
  997. {
  998.             Debug((stderr, "mod_list: modifier mod_list1\n"));
  999.             Debug((stderr, "\tmodifier='%s'\n", yypvt[-1].dynstr));
  1000.             Debug((stderr, "\tmod_list1='%s'\n", yypvt[-0].dynstr));
  1001.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(" "),yypvt[-0].dynstr,NullCP);
  1002.             } break;
  1003. case 73:
  1004. {
  1005.             Debug((stderr, "mod_list: modifier\n"));
  1006.             Debug((stderr, "\tmodifier='%s'\n", yypvt[-0].dynstr));
  1007.             yyval.dynstr = yypvt[-0].dynstr;
  1008.             } break;
  1009. case 74:
  1010. {
  1011.             Debug((stderr, "mod_list1: mod_list\n"));
  1012.             Debug((stderr, "\tmod_list='%s'\n", yypvt[-0].dynstr));
  1013.             yyval.dynstr = yypvt[-0].dynstr;
  1014.             } break;
  1015. case 75:
  1016. {
  1017.             Debug((stderr, "mod_list1: CONSTVOLATILE\n"));
  1018.             Debug((stderr, "\tCONSTVOLATILE='%s'\n", yypvt[-0].dynstr));
  1019.             if (PreANSIFlag)
  1020.                 notsupported(" (Pre-ANSI Compiler)", yypvt[-0].dynstr, NullCP);
  1021.             else if (RitchieFlag)
  1022.                 notsupported(" (Ritchie Compiler)", yypvt[-0].dynstr, NullCP);
  1023.             else if ((strcmp(yypvt[-0].dynstr, "noalias") == 0) && CplusplusFlag)
  1024.                 unsupp(yypvt[-0].dynstr, NullCP);
  1025.             yyval.dynstr = yypvt[-0].dynstr;
  1026.             } break;
  1027. case 76:
  1028. {
  1029.             Debug((stderr, "modifier: UNSIGNED\n"));
  1030.             Debug((stderr, "\tUNSIGNED='%s'\n", yypvt[-0].dynstr));
  1031.             modbits |= MB_UNSIGNED; yyval.dynstr = yypvt[-0].dynstr;
  1032.             } break;
  1033. case 77:
  1034. {
  1035.             Debug((stderr, "modifier: SIGNED\n"));
  1036.             Debug((stderr, "\tSIGNED='%s'\n", yypvt[-0].dynstr));
  1037.             modbits |= MB_SIGNED; yyval.dynstr = yypvt[-0].dynstr;
  1038.             } break;
  1039. case 78:
  1040. {
  1041.             Debug((stderr, "modifier: LONG\n"));
  1042.             Debug((stderr, "\tLONG='%s'\n", yypvt[-0].dynstr));
  1043.             modbits |= MB_LONG; yyval.dynstr = yypvt[-0].dynstr;
  1044.             } break;
  1045. case 79:
  1046. {
  1047.             Debug((stderr, "modifier: SHORT\n"));
  1048.             Debug((stderr, "\tSHORT='%s'\n", yypvt[-0].dynstr));
  1049.             modbits |= MB_SHORT; yyval.dynstr = yypvt[-0].dynstr;
  1050.             } break;
  1051. case 80:
  1052. {
  1053.             Debug((stderr, "opt_constvol_list: CONSTVOLATILE opt_constvol_list\n"));
  1054.             Debug((stderr, "\tCONSTVOLATILE='%s'\n", yypvt[-1].dynstr));
  1055.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-0].dynstr));
  1056.             if (PreANSIFlag)
  1057.                 notsupported(" (Pre-ANSI Compiler)", yypvt[-1].dynstr, NullCP);
  1058.             else if (RitchieFlag)
  1059.                 notsupported(" (Ritchie Compiler)", yypvt[-1].dynstr, NullCP);
  1060.             else if ((strcmp(yypvt[-1].dynstr, "noalias") == 0) && CplusplusFlag)
  1061.                 unsupp(yypvt[-1].dynstr, NullCP);
  1062.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(strlen(yypvt[-0].dynstr) ? " " : ""),yypvt[-0].dynstr,NullCP);
  1063.             } break;
  1064. case 81:
  1065. {
  1066.             Debug((stderr, "opt_constvol_list: EMPTY\n"));
  1067.             yyval.dynstr = ds("");
  1068.             } break;
  1069. case 82:
  1070. {
  1071.             Debug((stderr, "constvol_list: CONSTVOLATILE opt_constvol_list\n"));
  1072.             Debug((stderr, "\tCONSTVOLATILE='%s'\n", yypvt[-1].dynstr));
  1073.             Debug((stderr, "\topt_constvol_list='%s'\n", yypvt[-0].dynstr));
  1074.             if (PreANSIFlag)
  1075.                 notsupported(" (Pre-ANSI Compiler)", yypvt[-1].dynstr, NullCP);
  1076.             else if (RitchieFlag)
  1077.                 notsupported(" (Ritchie Compiler)", yypvt[-1].dynstr, NullCP);
  1078.             else if ((strcmp(yypvt[-1].dynstr, "noalias") == 0) && CplusplusFlag)
  1079.                 unsupp(yypvt[-1].dynstr, NullCP);
  1080.             yyval.dynstr = cat(yypvt[-1].dynstr,ds(strlen(yypvt[-0].dynstr) ? " " : ""),yypvt[-0].dynstr,NullCP);
  1081.             } break;
  1082. case 86:
  1083. {
  1084.             Debug((stderr, "storage: AUTO,EXTERN,STATIC,REGISTER (%s)\n", yypvt[-0].dynstr));
  1085.             yyval.dynstr = yypvt[-0].dynstr;
  1086.             } break;
  1087. case 87:
  1088. {
  1089.             Debug((stderr, "opt_storage: storage=%s\n", yypvt[-0].dynstr));
  1090.             yyval.dynstr = yypvt[-0].dynstr;
  1091.             } break;
  1092. case 88:
  1093. {
  1094.             Debug((stderr, "opt_storage: EMPTY\n"));
  1095.             yyval.dynstr = ds("");
  1096.             } break;
  1097.         }
  1098.         goto yystack;  /* stack new state and value */
  1099.  
  1100.     }
  1101. SHAR_EOF
  1102. cat << \SHAR_EOF > cdlex.c
  1103. # include "stdio.h"
  1104. # define U(x) x
  1105. # define NLSTATE yyprevious=YYNEWLINE
  1106. # define BEGIN yybgin = yysvec + 1 +
  1107. # define INITIAL 0
  1108. # define YYLERR yysvec
  1109. # define YYSTATE (yyestate-yysvec-1)
  1110. # define YYOPTIM 1
  1111. # define YYLMAX BUFSIZ
  1112. # define output(c) putc(c,yyout)
  1113. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  1114. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  1115. # define yymore() (yymorfg=1)
  1116. # define ECHO fprintf(yyout, "%s",yytext)
  1117. # define REJECT { nstr = yyreject(); goto yyfussy;}
  1118. int yyleng; extern char yytext[];
  1119. int yymorfg;
  1120. extern char *yysptr, yysbuf[];
  1121. int yytchar;
  1122. FILE *yyin = {stdin}, *yyout = {stdout};
  1123. extern int yylineno;
  1124. struct yysvf { 
  1125.     struct yywork *yystoff;
  1126.     struct yysvf *yyother;
  1127.     int *yystops;};
  1128. struct yysvf *yyestate;
  1129. extern struct yysvf yysvec[], *yybgin;
  1130. /* Lexical analyzer description for ANSI and C++ cdecl. */
  1131. /* The output of this file is included */
  1132. /* into the C file cdecl.c. */
  1133. char cdlexsccsid[] = "@(#)cdlex.l    2.2 3/30/88";
  1134. # define YYNEWLINE 10
  1135. yylex(){
  1136. int nstr; extern int yyprevious;
  1137. while((nstr = yylook()) >= 0)
  1138. yyfussy: switch(nstr){
  1139. case 0:
  1140. if(yywrap()) return(0); break;
  1141. case 1:
  1142.     return ARRAY;
  1143. break;
  1144. case 2:
  1145.     return AS;
  1146. break;
  1147. case 3:
  1148.     return CAST;
  1149. break;
  1150. case 4:
  1151.     return DECLARE;
  1152. break;
  1153. case 5:
  1154.     return 0;
  1155. break;
  1156. case 6:
  1157.     return EXPLAIN;
  1158. break;
  1159. case 7:
  1160. return FUNCTION;
  1161. break;
  1162. case 8:
  1163.     return FUNCTION;
  1164. break;
  1165. case 9:
  1166.     return HELP;
  1167. break;
  1168. case 10:
  1169.     return INTO;
  1170. break;
  1171. case 11:
  1172.     return MEMBER;
  1173. break;
  1174. case 12:
  1175.     return OF;
  1176. break;
  1177. case 13:
  1178.     return POINTER;
  1179. break;
  1180. case 14:
  1181.     return POINTER;
  1182. break;
  1183. case 15:
  1184.     return 0;
  1185. break;
  1186. case 16:
  1187. return REFERENCE;
  1188. break;
  1189. case 17:
  1190.     return REFERENCE;
  1191. break;
  1192. case 18:
  1193. return RETURNING;
  1194. break;
  1195. case 19:
  1196.     return RETURNING;
  1197. break;
  1198. case 20:
  1199.     return SET;
  1200. break;
  1201. case 21:
  1202.     return TO;
  1203. break;
  1204. case 22:
  1205.     return ARRAY;
  1206. break;
  1207. case 23:
  1208.     return DOUBLECOLON;
  1209. break;
  1210. case 24:
  1211.     return HELP;
  1212. break;
  1213. case 25:
  1214.     return COMMA;
  1215. break;
  1216. case 26:
  1217.     { yylval.dynstr = ds(yytext);    return AUTO; }
  1218. break;
  1219. case 27:
  1220. { yylval.dynstr = ds("char");    return CHAR; }
  1221. break;
  1222. case 28:
  1223.     { yylval.dynstr = ds(yytext);    return CHAR; }
  1224. break;
  1225. case 29:
  1226.     { yylval.dynstr = ds(yytext);    return CLASS; }
  1227. break;
  1228. case 30:
  1229. { yylval.dynstr = ds("const");    return CONSTVOLATILE; }
  1230. break;
  1231. case 31:
  1232.     { yylval.dynstr = ds(yytext);    return CONSTVOLATILE; }
  1233. break;
  1234. case 32:
  1235.     { yylval.dynstr = ds(yytext);    return DOUBLE; }
  1236. break;
  1237. case 33:
  1238. { yylval.dynstr = ds("enum");    return ENUM; }
  1239. break;
  1240. case 34:
  1241.     { yylval.dynstr = ds(yytext);    return ENUM; }
  1242. break;
  1243. case 35:
  1244.     { yylval.dynstr = ds(yytext);    return EXTERN; }
  1245. break;
  1246. case 36:
  1247.     { yylval.dynstr = ds(yytext);    return FLOAT; }
  1248. break;
  1249. case 37:
  1250.     { yylval.dynstr = ds("int");    return INT; }
  1251. break;
  1252. case 38:
  1253.     { yylval.dynstr = ds(yytext);    return INT; }
  1254. break;
  1255. case 39:
  1256.     { yylval.dynstr = ds(yytext);    return LONG; }
  1257. break;
  1258. case 40:
  1259.     { yylval.dynstr = ds(yytext);    return CONSTVOLATILE; }
  1260. break;
  1261. case 41:
  1262. { yylval.dynstr = ds(yytext);    return REGISTER; }
  1263. break;
  1264. case 42:
  1265.     { yylval.dynstr = ds(yytext);    return SHORT; }
  1266. break;
  1267. case 43:
  1268.     { yylval.dynstr = ds(yytext);    return SIGNED; }
  1269. break;
  1270. case 44:
  1271.     { yylval.dynstr = ds(yytext);    return STATIC; }
  1272. break;
  1273. case 45:
  1274. { yylval.dynstr = ds("struct");    return STRUCT; }
  1275. break;
  1276. case 46:
  1277.     { yylval.dynstr = ds(yytext);    return STRUCT; }
  1278. break;
  1279. case 47:
  1280.     { yylval.dynstr = ds(yytext);    return UNION; }
  1281. break;
  1282. case 48:
  1283. { yylval.dynstr = ds(yytext);    return UNSIGNED; }
  1284. break;
  1285. case 49:
  1286.     { yylval.dynstr = ds(yytext);    return VOID; }
  1287. break;
  1288. case 50:
  1289. { yylval.dynstr = ds(yytext);    return CONSTVOLATILE; }
  1290. break;
  1291. case 51:
  1292. { yylval.dynstr = ds(yytext);    return NAME; }
  1293. break;
  1294. case 52:
  1295.     { yylval.dynstr = ds(yytext);    return NUMBER; }
  1296. break;
  1297. case 53:
  1298.     ;
  1299. break;
  1300. case 54:
  1301.     ;
  1302. break;
  1303. case 55:
  1304. return *yytext;
  1305. break;
  1306. case 56:
  1307.     {
  1308.             (void) printf("bad character '%s'\n",visible(*yytext));
  1309.             return *yytext;
  1310.         }
  1311. break;
  1312. case -1:
  1313. break;
  1314. default:
  1315. fprintf(yyout,"bad switch yylook %d",nstr);
  1316. } return(0); }
  1317. /* end of yylex */
  1318. int yyvstop[] = {
  1319. 0,
  1320.  
  1321. 56,
  1322. 0,
  1323.  
  1324. 54,
  1325. 56,
  1326. 0,
  1327.  
  1328. 55,
  1329. 0,
  1330.  
  1331. 53,
  1332. 56,
  1333. 0,
  1334.  
  1335. 55,
  1336. 56,
  1337. 0,
  1338.  
  1339. 25,
  1340. 56,
  1341. 0,
  1342.  
  1343. 52,
  1344. 56,
  1345. 0,
  1346.  
  1347. 56,
  1348. 0,
  1349.  
  1350. 24,
  1351. 56,
  1352. 0,
  1353.  
  1354. 51,
  1355. 56,
  1356. 0,
  1357.  
  1358. 51,
  1359. 56,
  1360. 0,
  1361.  
  1362. 51,
  1363. 56,
  1364. 0,
  1365.  
  1366. 51,
  1367. 56,
  1368. 0,
  1369.  
  1370. 51,
  1371. 56,
  1372. 0,
  1373.  
  1374. 51,
  1375. 56,
  1376. 0,
  1377.  
  1378. 51,
  1379. 56,
  1380. 0,
  1381.  
  1382. 51,
  1383. 56,
  1384. 0,
  1385.  
  1386. 51,
  1387. 56,
  1388. 0,
  1389.  
  1390. 51,
  1391. 56,
  1392. 0,
  1393.  
  1394. 51,
  1395. 56,
  1396. 0,
  1397.  
  1398. 51,
  1399. 56,
  1400. 0,
  1401.  
  1402. 51,
  1403. 56,
  1404. 0,
  1405.  
  1406. 51,
  1407. 56,
  1408. 0,
  1409.  
  1410. 51,
  1411. 56,
  1412. 0,
  1413.  
  1414. 51,
  1415. 56,
  1416. 0,
  1417.  
  1418. 51,
  1419. 56,
  1420. 0,
  1421.  
  1422. 51,
  1423. 56,
  1424. 0,
  1425.  
  1426. 51,
  1427. 56,
  1428. 0,
  1429.  
  1430. 53,
  1431. 0,
  1432.  
  1433. 52,
  1434. 0,
  1435.  
  1436. 23,
  1437. 0,
  1438.  
  1439. 51,
  1440. 0,
  1441.  
  1442. 51,
  1443. 0,
  1444.  
  1445. 2,
  1446. 51,
  1447. 0,
  1448.  
  1449. 51,
  1450. 0,
  1451.  
  1452. 51,
  1453. 0,
  1454.  
  1455. 51,
  1456. 0,
  1457.  
  1458. 51,
  1459. 0,
  1460.  
  1461. 51,
  1462. 0,
  1463.  
  1464. 51,
  1465. 0,
  1466.  
  1467. 51,
  1468. 0,
  1469.  
  1470. 51,
  1471. 0,
  1472.  
  1473. 51,
  1474. 0,
  1475.  
  1476. 51,
  1477. 0,
  1478.  
  1479. 51,
  1480. 0,
  1481.  
  1482. 51,
  1483. 0,
  1484.  
  1485. 51,
  1486. 0,
  1487.  
  1488. 51,
  1489. 0,
  1490.  
  1491. 51,
  1492. 0,
  1493.  
  1494. 51,
  1495. 0,
  1496.  
  1497. 12,
  1498. 51,
  1499. 0,
  1500.  
  1501. 51,
  1502. 0,
  1503.  
  1504. 51,
  1505. 0,
  1506.  
  1507. 51,
  1508. 0,
  1509.  
  1510. 51,
  1511. 0,
  1512.  
  1513. 51,
  1514. 0,
  1515.  
  1516. 51,
  1517. 0,
  1518.  
  1519. 51,
  1520. 0,
  1521.  
  1522. 51,
  1523. 0,
  1524.  
  1525. 21,
  1526. 51,
  1527. 0,
  1528.  
  1529. 51,
  1530. 0,
  1531.  
  1532. 51,
  1533. 0,
  1534.  
  1535. 51,
  1536. 0,
  1537.  
  1538. 51,
  1539. 0,
  1540.  
  1541. 51,
  1542. 0,
  1543.  
  1544. 51,
  1545. 0,
  1546.  
  1547. 51,
  1548. 0,
  1549.  
  1550. 51,
  1551. 0,
  1552.  
  1553. 51,
  1554. 0,
  1555.  
  1556. 51,
  1557. 0,
  1558.  
  1559. 51,
  1560. 0,
  1561.  
  1562. 51,
  1563. 0,
  1564.  
  1565. 51,
  1566. 0,
  1567.  
  1568. 51,
  1569. 0,
  1570.  
  1571. 51,
  1572. 0,
  1573.  
  1574. 51,
  1575. 0,
  1576.  
  1577. 51,
  1578. 0,
  1579.  
  1580. 51,
  1581. 0,
  1582.  
  1583. 38,
  1584. 51,
  1585. 0,
  1586.  
  1587. 51,
  1588. 0,
  1589.  
  1590. 51,
  1591. 0,
  1592.  
  1593. 51,
  1594. 0,
  1595.  
  1596. 51,
  1597. 0,
  1598.  
  1599. 14,
  1600. 51,
  1601. 0,
  1602.  
  1603. 51,
  1604. 0,
  1605.  
  1606. 17,
  1607. 51,
  1608. 0,
  1609.  
  1610. 51,
  1611. 0,
  1612.  
  1613. 19,
  1614. 51,
  1615. 0,
  1616.  
  1617. 20,
  1618. 51,
  1619. 0,
  1620.  
  1621. 51,
  1622. 0,
  1623.  
  1624. 51,
  1625. 0,
  1626.  
  1627. 51,
  1628. 0,
  1629.  
  1630. 51,
  1631. 0,
  1632.  
  1633. 51,
  1634. 0,
  1635.  
  1636. 51,
  1637. 0,
  1638.  
  1639. 51,
  1640. 0,
  1641.  
  1642. 51,
  1643. 0,
  1644.  
  1645. 51,
  1646. 0,
  1647.  
  1648. 51,
  1649. 0,
  1650.  
  1651. 26,
  1652. 51,
  1653. 0,
  1654.  
  1655. 3,
  1656. 51,
  1657. 0,
  1658.  
  1659. 28,
  1660. 51,
  1661. 0,
  1662.  
  1663. 51,
  1664. 0,
  1665.  
  1666. 51,
  1667. 0,
  1668.  
  1669. 51,
  1670. 0,
  1671.  
  1672. 51,
  1673. 0,
  1674.  
  1675. 34,
  1676. 51,
  1677. 0,
  1678.  
  1679. 5,
  1680. 51,
  1681. 0,
  1682.  
  1683. 51,
  1684. 0,
  1685.  
  1686. 51,
  1687. 0,
  1688.  
  1689. 51,
  1690. 0,
  1691.  
  1692. 8,
  1693. 51,
  1694. 0,
  1695.  
  1696. 9,
  1697. 51,
  1698. 0,
  1699.  
  1700. 51,
  1701. 0,
  1702.  
  1703. 10,
  1704. 51,
  1705. 0,
  1706.  
  1707. 39,
  1708. 51,
  1709. 0,
  1710.  
  1711. 51,
  1712. 0,
  1713.  
  1714. 51,
  1715. 0,
  1716.  
  1717. 51,
  1718. 0,
  1719.  
  1720. 15,
  1721. 51,
  1722. 0,
  1723.  
  1724. 51,
  1725. 0,
  1726.  
  1727. 51,
  1728. 0,
  1729.  
  1730. 51,
  1731. 0,
  1732.  
  1733. 51,
  1734. 0,
  1735.  
  1736. 51,
  1737. 0,
  1738.  
  1739. 51,
  1740. 0,
  1741.  
  1742. 51,
  1743. 0,
  1744.  
  1745. 51,
  1746. 0,
  1747.  
  1748. 51,
  1749. 0,
  1750.  
  1751. 51,
  1752. 0,
  1753.  
  1754. 49,
  1755. 51,
  1756. 0,
  1757.  
  1758. 51,
  1759. 0,
  1760.  
  1761. 1,
  1762. 51,
  1763. 0,
  1764.  
  1765. 51,
  1766. 0,
  1767.  
  1768. 29,
  1769. 51,
  1770. 0,
  1771.  
  1772. 31,
  1773. 51,
  1774. 0,
  1775.  
  1776. 51,
  1777. 0,
  1778.  
  1779. 51,
  1780. 0,
  1781.  
  1782. 51,
  1783. 0,
  1784.  
  1785. 51,
  1786. 0,
  1787.  
  1788. 51,
  1789. 0,
  1790.  
  1791. 36,
  1792. 51,
  1793. 0,
  1794.  
  1795. 51,
  1796. 0,
  1797.  
  1798. 51,
  1799. 0,
  1800.  
  1801. 51,
  1802. 0,
  1803.  
  1804. 51,
  1805. 0,
  1806.  
  1807. 51,
  1808. 0,
  1809.  
  1810. 51,
  1811. 0,
  1812.  
  1813. 51,
  1814. 0,
  1815.  
  1816. 51,
  1817. 0,
  1818.  
  1819. 42,
  1820. 51,
  1821. 0,
  1822.  
  1823. 51,
  1824. 0,
  1825.  
  1826. 51,
  1827. 0,
  1828.  
  1829. 51,
  1830. 0,
  1831.  
  1832. 47,
  1833. 51,
  1834. 0,
  1835.  
  1836. 51,
  1837. 0,
  1838.  
  1839. 51,
  1840. 0,
  1841.  
  1842. 51,
  1843. 0,
  1844.  
  1845. 51,
  1846. 0,
  1847.  
  1848. 51,
  1849. 0,
  1850.  
  1851. 51,
  1852. 0,
  1853.  
  1854. 32,
  1855. 51,
  1856. 0,
  1857.  
  1858. 51,
  1859. 0,
  1860.  
  1861. 51,
  1862. 0,
  1863.  
  1864. 35,
  1865. 51,
  1866. 0,
  1867.  
  1868. 51,
  1869. 0,
  1870.  
  1871. 51,
  1872. 0,
  1873.  
  1874. 11,
  1875. 51,
  1876. 0,
  1877.  
  1878. 51,
  1879. 0,
  1880.  
  1881. 51,
  1882. 0,
  1883.  
  1884. 51,
  1885. 0,
  1886.  
  1887. 51,
  1888. 0,
  1889.  
  1890. 51,
  1891. 0,
  1892.  
  1893. 43,
  1894. 51,
  1895. 0,
  1896.  
  1897. 44,
  1898. 51,
  1899. 0,
  1900.  
  1901. 46,
  1902. 51,
  1903. 0,
  1904.  
  1905. 51,
  1906. 0,
  1907.  
  1908. 22,
  1909. 51,
  1910. 0,
  1911.  
  1912. 51,
  1913. 0,
  1914.  
  1915. 51,
  1916. 0,
  1917.  
  1918. 51,
  1919. 0,
  1920.  
  1921. 4,
  1922. 51,
  1923. 0,
  1924.  
  1925. 51,
  1926. 0,
  1927.  
  1928. 6,
  1929. 51,
  1930. 0,
  1931.  
  1932. 51,
  1933. 0,
  1934.  
  1935. 37,
  1936. 51,
  1937. 0,
  1938.  
  1939. 40,
  1940. 51,
  1941. 0,
  1942.  
  1943. 13,
  1944. 51,
  1945. 0,
  1946.  
  1947. 51,
  1948. 0,
  1949.  
  1950. 51,
  1951. 0,
  1952.  
  1953. 51,
  1954. 0,
  1955.  
  1956. 51,
  1957. 0,
  1958.  
  1959. 51,
  1960. 0,
  1961.  
  1962. 51,
  1963. 0,
  1964.  
  1965. 51,
  1966. 0,
  1967.  
  1968. 30,
  1969. 51,
  1970. 0,
  1971.  
  1972. 51,
  1973. 0,
  1974.  
  1975. 7,
  1976. 51,
  1977. 0,
  1978.  
  1979. 51,
  1980. 0,
  1981.  
  1982. 41,
  1983. 51,
  1984. 0,
  1985.  
  1986. 51,
  1987. 0,
  1988.  
  1989. 51,
  1990. 0,
  1991.  
  1992. 48,
  1993. 51,
  1994. 0,
  1995.  
  1996. 50,
  1997. 51,
  1998. 0,
  1999.  
  2000. 27,
  2001. 51,
  2002. 0,
  2003.  
  2004. 51,
  2005. 0,
  2006.  
  2007. 16,
  2008. 51,
  2009. 0,
  2010.  
  2011. 18,
  2012. 51,
  2013. 0,
  2014.  
  2015. 45,
  2016. 51,
  2017. 0,
  2018.  
  2019. 51,
  2020. 0,
  2021.  
  2022. 33,
  2023. 51,
  2024. 0,
  2025. 0};
  2026. # define YYTYPE int
  2027. struct yywork { YYTYPE verify, advance; } yycrank[] = {
  2028. 0,0,    0,0,    1,3,    0,0,    
  2029. 0,0,    0,0,    0,0,    6,31,    
  2030. 0,0,    0,0,    1,4,    1,5,    
  2031. 0,0,    0,0,    0,0,    6,31,    
  2032. 6,0,    0,0,    0,0,    0,0,    
  2033. 0,0,    0,0,    0,0,    0,0,    
  2034. 0,0,    0,0,    0,0,    0,0,    
  2035. 0,0,    0,0,    0,0,    0,0,    
  2036. 0,0,    0,0,    0,0,    0,0,    
  2037. 1,6,    0,0,    0,0,    1,7,    
  2038. 0,0,    6,31,    0,0,    0,0,    
  2039. 6,31,    1,8,    0,0,    0,0,    
  2040. 0,0,    1,9,    6,31,    0,0,    
  2041. 0,0,    0,0,    6,31,    0,0,    
  2042. 0,0,    0,0,    0,0,    1,10,    
  2043. 10,33,    0,0,    0,0,    0,0,    
  2044. 1,11,    0,0,    1,12,    0,0,    
  2045. 0,0,    6,31,    0,0,    6,31,    
  2046. 0,0,    0,0,    0,0,    0,0,    
  2047. 0,0,    0,0,    0,0,    0,0,    
  2048. 0,0,    2,10,    9,32,    9,32,    
  2049. 9,32,    9,32,    9,32,    9,32,    
  2050. 9,32,    9,32,    9,32,    9,32,    
  2051. 0,0,    0,0,    0,0,    0,0,    
  2052. 0,0,    0,0,    1,13,    0,0,    
  2053. 1,14,    1,15,    1,16,    1,17,    
  2054. 18,48,    1,18,    1,19,    31,0,    
  2055. 0,0,    1,20,    1,21,    1,22,    
  2056. 1,23,    1,24,    1,25,    1,26,    
  2057. 1,27,    1,28,    1,29,    1,30,    
  2058. 2,13,    17,46,    2,14,    2,15,    
  2059. 2,16,    2,17,    19,49,    2,18,    
  2060. 2,19,    20,50,    17,47,    2,20,    
  2061. 2,21,    2,22,    2,23,    2,24,    
  2062. 2,25,    2,26,    2,27,    2,28,    
  2063. 2,29,    2,30,    12,34,    12,34,    
  2064. 12,34,    12,34,    12,34,    12,34,    
  2065. 12,34,    12,34,    12,34,    12,34,    
  2066. 13,35,    13,36,    21,51,    13,37,    
  2067. 22,52,    23,53,    25,56,    12,34,    
  2068. 12,34,    12,34,    12,34,    12,34,    
  2069. 12,34,    12,34,    12,34,    12,34,    
  2070. 12,34,    12,34,    12,34,    12,34,    
  2071. 12,34,    12,34,    12,34,    12,34,    
  2072. 12,34,    12,34,    12,34,    12,34,    
  2073. 12,34,    12,34,    12,34,    12,34,    
  2074. 12,34,    24,54,    26,57,    28,62,    
  2075. 29,63,    12,34,    24,55,    12,34,    
  2076. 12,34,    12,34,    12,34,    12,34,    
  2077. 12,34,    12,34,    12,34,    12,34,    
  2078. 12,34,    12,34,    12,34,    12,34,    
  2079. 12,34,    12,34,    12,34,    12,34,    
  2080. 12,34,    12,34,    12,34,    12,34,    
  2081. 12,34,    12,34,    12,34,    12,34,    
  2082. 12,34,    14,38,    27,58,    15,42,    
  2083. 16,44,    27,59,    27,60,    35,66,    
  2084. 14,39,    30,64,    37,67,    38,68,    
  2085. 14,40,    15,43,    16,45,    14,41,    
  2086. 39,69,    27,61,    40,70,    30,65,    
  2087. 41,71,    42,72,    43,73,    44,74,    
  2088. 45,75,    46,78,    47,79,    48,80,    
  2089. 49,81,    50,82,    51,83,    45,76,    
  2090. 52,84,    54,85,    55,86,    45,77,    
  2091. 56,87,    57,88,    57,89,    58,91,    
  2092. 59,92,    60,93,    61,94,    63,96,    
  2093. 64,98,    65,99,    66,101,    67,102,    
  2094. 65,100,    68,103,    69,104,    57,90,    
  2095. 70,105,    63,97,    71,106,    72,107,    
  2096. 73,108,    74,109,    75,110,    61,95,    
  2097. 76,111,    77,112,    78,113,    79,114,    
  2098. 80,115,    81,116,    82,118,    83,119,    
  2099. 84,120,    85,121,    87,122,    88,123,    
  2100. 89,124,    90,125,    92,126,    81,117,    
  2101. 93,127,    94,128,    95,129,    96,130,    
  2102. 97,131,    98,132,    99,133,    100,134,    
  2103. 101,135,    104,136,    105,137,    106,138,    
  2104. 107,139,    108,140,    109,141,    111,142,    
  2105. 112,143,    113,144,    114,145,    116,146,    
  2106. 119,147,    120,148,    121,149,    123,150,    
  2107. 124,151,    125,152,    126,153,    127,154,    
  2108. 128,155,    129,156,    130,157,    131,158,    
  2109. 132,159,    134,160,    136,161,    138,162,    
  2110. 139,163,    140,164,    141,165,    142,166,    
  2111. 143,167,    145,168,    146,169,    147,170,    
  2112. 148,171,    149,172,    150,173,    151,174,    
  2113. 152,175,    154,176,    155,177,    156,178,    
  2114. 158,179,    159,180,    160,181,    161,182,    
  2115. 162,183,    163,184,    165,185,    166,186,    
  2116. 168,187,    169,188,    171,189,    172,190,    
  2117. 173,191,    174,192,    175,193,    178,194,    
  2118. 179,195,    181,196,    182,197,    183,198,    
  2119. 185,199,    187,200,    191,201,    192,202,    
  2120. 193,203,    194,204,    195,205,    196,206,    
  2121. 197,207,    199,208,    201,209,    203,210,    
  2122. 204,211,    208,212,    212,213,    0,0,    
  2123. 0,0};
  2124. struct yysvf yysvec[] = {
  2125. 0,    0,    0,
  2126. yycrank+-1,    0,        0,    
  2127. yycrank+-23,    yysvec+1,    0,    
  2128. yycrank+0,    0,        yyvstop+1,
  2129. yycrank+0,    0,        yyvstop+3,
  2130. yycrank+0,    0,        yyvstop+6,
  2131. yycrank+-6,    0,        yyvstop+8,
  2132. yycrank+0,    0,        yyvstop+11,
  2133. yycrank+0,    0,        yyvstop+14,
  2134. yycrank+34,    0,        yyvstop+17,
  2135. yycrank+2,    0,        yyvstop+20,
  2136. yycrank+0,    0,        yyvstop+22,
  2137. yycrank+94,    0,        yyvstop+25,
  2138. yycrank+38,    yysvec+12,    yyvstop+28,
  2139. yycrank+120,    yysvec+12,    yyvstop+31,
  2140. yycrank+118,    yysvec+12,    yyvstop+34,
  2141. yycrank+110,    yysvec+12,    yyvstop+37,
  2142. yycrank+13,    yysvec+12,    yyvstop+40,
  2143. yycrank+3,    yysvec+12,    yyvstop+43,
  2144. yycrank+16,    yysvec+12,    yyvstop+46,
  2145. yycrank+18,    yysvec+12,    yyvstop+49,
  2146. yycrank+53,    yysvec+12,    yyvstop+52,
  2147. yycrank+45,    yysvec+12,    yyvstop+55,
  2148. yycrank+55,    yysvec+12,    yyvstop+58,
  2149. yycrank+74,    yysvec+12,    yyvstop+61,
  2150. yycrank+41,    yysvec+12,    yyvstop+64,
  2151. yycrank+85,    yysvec+12,    yyvstop+67,
  2152. yycrank+117,    yysvec+12,    yyvstop+70,
  2153. yycrank+76,    yysvec+12,    yyvstop+73,
  2154. yycrank+78,    yysvec+12,    yyvstop+76,
  2155. yycrank+124,    yysvec+12,    yyvstop+79,
  2156. yycrank+-97,    yysvec+6,    yyvstop+82,
  2157. yycrank+0,    yysvec+9,    yyvstop+84,
  2158. yycrank+0,    0,        yyvstop+86,
  2159. yycrank+0,    yysvec+12,    yyvstop+88,
  2160. yycrank+109,    yysvec+12,    yyvstop+90,
  2161. yycrank+0,    yysvec+12,    yyvstop+92,
  2162. yycrank+110,    yysvec+12,    yyvstop+95,
  2163. yycrank+112,    yysvec+12,    yyvstop+97,
  2164. yycrank+135,    yysvec+12,    yyvstop+99,
  2165. yycrank+137,    yysvec+12,    yyvstop+101,
  2166. yycrank+126,    yysvec+12,    yyvstop+103,
  2167. yycrank+138,    yysvec+12,    yyvstop+105,
  2168. yycrank+121,    yysvec+12,    yyvstop+107,
  2169. yycrank+122,    yysvec+12,    yyvstop+109,
  2170. yycrank+135,    yysvec+12,    yyvstop+111,
  2171. yycrank+130,    yysvec+12,    yyvstop+113,
  2172. yycrank+132,    yysvec+12,    yyvstop+115,
  2173. yycrank+135,    yysvec+12,    yyvstop+117,
  2174. yycrank+128,    yysvec+12,    yyvstop+119,
  2175. yycrank+135,    yysvec+12,    yyvstop+121,
  2176. yycrank+137,    yysvec+12,    yyvstop+123,
  2177. yycrank+151,    yysvec+12,    yyvstop+125,
  2178. yycrank+0,    yysvec+12,    yyvstop+127,
  2179. yycrank+144,    yysvec+12,    yyvstop+130,
  2180. yycrank+136,    yysvec+12,    yyvstop+132,
  2181. yycrank+147,    yysvec+12,    yyvstop+134,
  2182. yycrank+151,    yysvec+12,    yyvstop+136,
  2183. yycrank+139,    yysvec+12,    yyvstop+138,
  2184. yycrank+145,    yysvec+12,    yyvstop+140,
  2185. yycrank+154,    yysvec+12,    yyvstop+142,
  2186. yycrank+161,    yysvec+12,    yyvstop+144,
  2187. yycrank+0,    yysvec+12,    yyvstop+146,
  2188. yycrank+154,    yysvec+12,    yyvstop+149,
  2189. yycrank+161,    yysvec+12,    yyvstop+151,
  2190. yycrank+156,    yysvec+12,    yyvstop+153,
  2191. yycrank+165,    yysvec+12,    yyvstop+155,
  2192. yycrank+152,    yysvec+12,    yyvstop+157,
  2193. yycrank+149,    yysvec+12,    yyvstop+159,
  2194. yycrank+152,    yysvec+12,    yyvstop+161,
  2195. yycrank+153,    yysvec+12,    yyvstop+163,
  2196. yycrank+155,    yysvec+12,    yyvstop+165,
  2197. yycrank+163,    yysvec+12,    yyvstop+167,
  2198. yycrank+174,    yysvec+12,    yyvstop+169,
  2199. yycrank+164,    yysvec+12,    yyvstop+171,
  2200. yycrank+158,    yysvec+12,    yyvstop+173,
  2201. yycrank+168,    yysvec+12,    yyvstop+175,
  2202. yycrank+176,    yysvec+12,    yyvstop+177,
  2203. yycrank+181,    yysvec+12,    yyvstop+179,
  2204. yycrank+180,    yysvec+12,    yyvstop+181,
  2205. yycrank+168,    yysvec+12,    yyvstop+183,
  2206. yycrank+180,    yysvec+12,    yyvstop+185,
  2207. yycrank+179,    yysvec+12,    yyvstop+188,
  2208. yycrank+185,    yysvec+12,    yyvstop+190,
  2209. yycrank+176,    yysvec+12,    yyvstop+192,
  2210. yycrank+175,    yysvec+12,    yyvstop+194,
  2211. yycrank+0,    yysvec+12,    yyvstop+196,
  2212. yycrank+170,    yysvec+12,    yyvstop+199,
  2213. yycrank+186,    yysvec+12,    yyvstop+201,
  2214. yycrank+183,    yysvec+12,    yyvstop+204,
  2215. yycrank+172,    yysvec+12,    yyvstop+206,
  2216. yycrank+0,    yysvec+12,    yyvstop+209,
  2217. yycrank+176,    yysvec+12,    yyvstop+212,
  2218. yycrank+182,    yysvec+12,    yyvstop+214,
  2219. yycrank+177,    yysvec+12,    yyvstop+216,
  2220. yycrank+177,    yysvec+12,    yyvstop+218,
  2221. yycrank+184,    yysvec+12,    yyvstop+220,
  2222. yycrank+191,    yysvec+12,    yyvstop+222,
  2223. yycrank+181,    yysvec+12,    yyvstop+224,
  2224. yycrank+198,    yysvec+12,    yyvstop+226,
  2225. yycrank+202,    yysvec+12,    yyvstop+228,
  2226. yycrank+179,    yysvec+12,    yyvstop+230,
  2227. yycrank+0,    yysvec+12,    yyvstop+232,
  2228. yycrank+0,    yysvec+12,    yyvstop+235,
  2229. yycrank+204,    yysvec+12,    yyvstop+238,
  2230. yycrank+187,    yysvec+12,    yyvstop+241,
  2231. yycrank+187,    yysvec+12,    yyvstop+243,
  2232. yycrank+207,    yysvec+12,    yyvstop+245,
  2233. yycrank+197,    yysvec+12,    yyvstop+247,
  2234. yycrank+205,    yysvec+12,    yyvstop+249,
  2235. yycrank+0,    yysvec+12,    yyvstop+252,
  2236. yycrank+210,    yysvec+12,    yyvstop+255,
  2237. yycrank+194,    yysvec+12,    yyvstop+257,
  2238. yycrank+193,    yysvec+12,    yyvstop+259,
  2239. yycrank+194,    yysvec+12,    yyvstop+261,
  2240. yycrank+0,    yysvec+12,    yyvstop+264,
  2241. yycrank+208,    yysvec+12,    yyvstop+267,
  2242. yycrank+0,    yysvec+12,    yyvstop+269,
  2243. yycrank+0,    yysvec+12,    yyvstop+272,
  2244. yycrank+211,    yysvec+12,    yyvstop+275,
  2245. yycrank+208,    yysvec+12,    yyvstop+277,
  2246. yycrank+198,    yysvec+12,    yyvstop+279,
  2247. yycrank+0,    yysvec+12,    yyvstop+281,
  2248. yycrank+201,    yysvec+12,    yyvstop+284,
  2249. yycrank+201,    yysvec+12,    yyvstop+286,
  2250. yycrank+203,    yysvec+12,    yyvstop+288,
  2251. yycrank+202,    yysvec+12,    yyvstop+290,
  2252. yycrank+218,    yysvec+12,    yyvstop+292,
  2253. yycrank+215,    yysvec+12,    yyvstop+294,
  2254. yycrank+222,    yysvec+12,    yyvstop+296,
  2255. yycrank+212,    yysvec+12,    yyvstop+298,
  2256. yycrank+220,    yysvec+12,    yyvstop+300,
  2257. yycrank+213,    yysvec+12,    yyvstop+302,
  2258. yycrank+0,    yysvec+12,    yyvstop+304,
  2259. yycrank+209,    yysvec+12,    yyvstop+307,
  2260. yycrank+0,    yysvec+12,    yyvstop+309,
  2261. yycrank+227,    yysvec+12,    yyvstop+312,
  2262. yycrank+0,    yysvec+12,    yyvstop+314,
  2263. yycrank+230,    yysvec+12,    yyvstop+317,
  2264. yycrank+214,    yysvec+12,    yyvstop+320,
  2265. yycrank+228,    yysvec+12,    yyvstop+322,
  2266. yycrank+216,    yysvec+12,    yyvstop+324,
  2267. yycrank+226,    yysvec+12,    yyvstop+326,
  2268. yycrank+222,    yysvec+12,    yyvstop+328,
  2269. yycrank+0,    yysvec+12,    yyvstop+330,
  2270. yycrank+228,    yysvec+12,    yyvstop+333,
  2271. yycrank+233,    yysvec+12,    yyvstop+335,
  2272. yycrank+221,    yysvec+12,    yyvstop+337,
  2273. yycrank+239,    yysvec+12,    yyvstop+339,
  2274. yycrank+236,    yysvec+12,    yyvstop+341,
  2275. yycrank+237,    yysvec+12,    yyvstop+343,
  2276. yycrank+223,    yysvec+12,    yyvstop+345,
  2277. yycrank+230,    yysvec+12,    yyvstop+347,
  2278. yycrank+0,    yysvec+12,    yyvstop+349,
  2279. yycrank+241,    yysvec+12,    yyvstop+352,
  2280. yycrank+243,    yysvec+12,    yyvstop+354,
  2281. yycrank+227,    yysvec+12,    yyvstop+356,
  2282. yycrank+0,    yysvec+12,    yyvstop+358,
  2283. yycrank+234,    yysvec+12,    yyvstop+361,
  2284. yycrank+231,    yysvec+12,    yyvstop+363,
  2285. yycrank+241,    yysvec+12,    yyvstop+365,
  2286. yycrank+231,    yysvec+12,    yyvstop+367,
  2287. yycrank+238,    yysvec+12,    yyvstop+369,
  2288. yycrank+248,    yysvec+12,    yyvstop+371,
  2289. yycrank+0,    yysvec+12,    yyvstop+373,
  2290. yycrank+253,    yysvec+12,    yyvstop+376,
  2291. yycrank+241,    yysvec+12,    yyvstop+378,
  2292. yycrank+0,    yysvec+12,    yyvstop+380,
  2293. yycrank+241,    yysvec+12,    yyvstop+383,
  2294. yycrank+239,    yysvec+12,    yyvstop+385,
  2295. yycrank+0,    yysvec+12,    yyvstop+387,
  2296. yycrank+239,    yysvec+12,    yyvstop+390,
  2297. yycrank+241,    yysvec+12,    yyvstop+392,
  2298. yycrank+246,    yysvec+12,    yyvstop+394,
  2299. yycrank+256,    yysvec+12,    yyvstop+396,
  2300. yycrank+253,    yysvec+12,    yyvstop+398,
  2301. yycrank+0,    yysvec+12,    yyvstop+400,
  2302. yycrank+0,    yysvec+12,    yyvstop+403,
  2303. yycrank+242,    yysvec+12,    yyvstop+406,
  2304. yycrank+259,    yysvec+12,    yyvstop+409,
  2305. yycrank+0,    yysvec+12,    yyvstop+411,
  2306. yycrank+253,    yysvec+12,    yyvstop+414,
  2307. yycrank+261,    yysvec+12,    yyvstop+416,
  2308. yycrank+247,    yysvec+12,    yyvstop+418,
  2309. yycrank+0,    yysvec+12,    yyvstop+420,
  2310. yycrank+248,    yysvec+12,    yyvstop+423,
  2311. yycrank+0,    yysvec+12,    yyvstop+425,
  2312. yycrank+255,    yysvec+12,    yyvstop+428,
  2313. yycrank+0,    yysvec+12,    yyvstop+430,
  2314. yycrank+0,    yysvec+12,    yyvstop+433,
  2315. yycrank+0,    yysvec+12,    yyvstop+436,
  2316. yycrank+267,    yysvec+12,    yyvstop+439,
  2317. yycrank+253,    yysvec+12,    yyvstop+441,
  2318. yycrank+258,    yysvec+12,    yyvstop+443,
  2319. yycrank+255,    yysvec+12,    yyvstop+445,
  2320. yycrank+270,    yysvec+12,    yyvstop+447,
  2321. yycrank+270,    yysvec+12,    yyvstop+449,
  2322. yycrank+258,    yysvec+12,    yyvstop+451,
  2323. yycrank+0,    yysvec+12,    yyvstop+453,
  2324. yycrank+268,    yysvec+12,    yyvstop+456,
  2325. yycrank+0,    yysvec+12,    yyvstop+458,
  2326. yycrank+273,    yysvec+12,    yyvstop+461,
  2327. yycrank+0,    yysvec+12,    yyvstop+463,
  2328. yycrank+272,    yysvec+12,    yyvstop+466,
  2329. yycrank+275,    yysvec+12,    yyvstop+468,
  2330. yycrank+0,    yysvec+12,    yyvstop+470,
  2331. yycrank+0,    yysvec+12,    yyvstop+473,
  2332. yycrank+0,    yysvec+12,    yyvstop+476,
  2333. yycrank+266,    yysvec+12,    yyvstop+479,
  2334. yycrank+0,    yysvec+12,    yyvstop+481,
  2335. yycrank+0,    yysvec+12,    yyvstop+484,
  2336. yycrank+0,    yysvec+12,    yyvstop+487,
  2337. yycrank+268,    yysvec+12,    yyvstop+490,
  2338. yycrank+0,    yysvec+12,    yyvstop+492,
  2339. 0,    0,    0};
  2340. struct yywork *yytop = yycrank+378;
  2341. struct yysvf *yybgin = yysvec+1;
  2342. char yymatch[] = {
  2343. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2344. 01  ,011 ,012 ,01  ,01  ,01  ,01  ,01  ,
  2345. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2346. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  2347. 011 ,01  ,01  ,'#' ,01  ,01  ,'&' ,01  ,
  2348. '&' ,'&' ,'&' ,01  ,',' ,01  ,01  ,01  ,
  2349. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  2350. '0' ,'0' ,01  ,'&' ,01  ,01  ,01  ,'?' ,
  2351. 01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  2352. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  2353. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  2354. 'A' ,'A' ,'A' ,'&' ,01  ,'&' ,01  ,'A' ,
  2355. 01  ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  2356. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  2357. 'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,'A' ,
  2358. 'A' ,'A' ,'A' ,01  ,01  ,01  ,01  ,01  ,
  2359. 0};
  2360. char yyextra[] = {
  2361. 0,0,0,0,0,0,0,0,
  2362. 0,0,0,0,0,0,0,0,
  2363. 0,0,0,0,0,0,0,0,
  2364. 0,0,0,0,0,0,0,0,
  2365. 0,0,0,0,0,0,0,0,
  2366. 0,0,0,0,0,0,0,0,
  2367. 0,0,0,0,0,0,0,0,
  2368. 0,0,0,0,0,0,0,0,
  2369. 0};
  2370. #ifndef lint
  2371. static    char ncform_sccsid[] = "@(#)ncform 1.1 86/07/08 SMI"; /* from S5R2 1.2 */
  2372. #endif
  2373.  
  2374. int yylineno =1;
  2375. # define YYU(x) x
  2376. # define NLSTATE yyprevious=YYNEWLINE
  2377. char yytext[YYLMAX];
  2378. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  2379. char yysbuf[YYLMAX];
  2380. char *yysptr = yysbuf;
  2381. int *yyfnd;
  2382. extern struct yysvf *yyestate;
  2383. int yyprevious = YYNEWLINE;
  2384. yylook(){
  2385.     register struct yysvf *yystate, **lsp;
  2386.     register struct yywork *yyt;
  2387.     struct yysvf *yyz;
  2388.     int yych, yyfirst;
  2389.     struct yywork *yyr;
  2390. # ifdef LEXDEBUG
  2391.     int debug;
  2392. # endif
  2393.     char *yylastch;
  2394.     /* start off machines */
  2395. # ifdef LEXDEBUG
  2396.     debug = 0;
  2397. # endif
  2398.     yyfirst=1;
  2399.     if (!yymorfg)
  2400.         yylastch = yytext;
  2401.     else {
  2402.         yymorfg=0;
  2403.         yylastch = yytext+yyleng;
  2404.         }
  2405.     for(;;){
  2406.         lsp = yylstate;
  2407.         yyestate = yystate = yybgin;
  2408.         if (yyprevious==YYNEWLINE) yystate++;
  2409.         for (;;){
  2410. # ifdef LEXDEBUG
  2411.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  2412. # endif
  2413.             yyt = yystate->yystoff;
  2414.             if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
  2415.                 yyz = yystate->yyother;
  2416.                 if(yyz == 0)break;
  2417.                 if(yyz->yystoff == yycrank)break;
  2418.                 }
  2419.             *yylastch++ = yych = input();
  2420.             yyfirst=0;
  2421.         tryagain:
  2422. # ifdef LEXDEBUG
  2423.             if(debug){
  2424.                 fprintf(yyout,"char ");
  2425.                 allprint(yych);
  2426.                 putchar('\n');
  2427.                 }
  2428. # endif
  2429.             yyr = yyt;
  2430.             if ( (int)yyt > (int)yycrank){
  2431.                 yyt = yyr + yych;
  2432.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  2433.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  2434.                         {unput(*--yylastch);break;}
  2435.                     *lsp++ = yystate = yyt->advance+yysvec;
  2436.                     goto contin;
  2437.                     }
  2438.                 }
  2439. # ifdef YYOPTIM
  2440.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  2441.                 yyt = yyr = yycrank+(yycrank-yyt);
  2442. # ifdef LEXDEBUG
  2443.                 if(debug)fprintf(yyout,"compressed state\n");
  2444. # endif
  2445.                 yyt = yyt + yych;
  2446.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  2447.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  2448.                         {unput(*--yylastch);break;}
  2449.                     *lsp++ = yystate = yyt->advance+yysvec;
  2450.                     goto contin;
  2451.                     }
  2452.                 yyt = yyr + YYU(yymatch[yych]);
  2453. # ifdef LEXDEBUG
  2454.                 if(debug){
  2455.                     fprintf(yyout,"try fall back character ");
  2456.                     allprint(YYU(yymatch[yych]));
  2457.                     putchar('\n');
  2458.                     }
  2459. # endif
  2460.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  2461.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  2462.                         {unput(*--yylastch);break;}
  2463.                     *lsp++ = yystate = yyt->advance+yysvec;
  2464.                     goto contin;
  2465.                     }
  2466.                 }
  2467.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  2468. # ifdef LEXDEBUG
  2469.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  2470. # endif
  2471.                 goto tryagain;
  2472.                 }
  2473. # endif
  2474.             else
  2475.                 {unput(*--yylastch);break;}
  2476.         contin:
  2477. # ifdef LEXDEBUG
  2478.             if(debug){
  2479.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  2480.                 allprint(yych);
  2481.                 putchar('\n');
  2482.                 }
  2483. # endif
  2484.             ;
  2485.             }
  2486. # ifdef LEXDEBUG
  2487.         if(debug){
  2488.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  2489.             allprint(yych);
  2490.             putchar('\n');
  2491.             }
  2492. # endif
  2493.         while (lsp-- > yylstate){
  2494.             *yylastch-- = 0;
  2495.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  2496.                 yyolsp = lsp;
  2497.                 if(yyextra[*yyfnd]){        /* must backup */
  2498.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  2499.                         lsp--;
  2500.                         unput(*yylastch--);
  2501.                         }
  2502.                     }
  2503.                 yyprevious = YYU(*yylastch);
  2504.                 yylsp = lsp;
  2505.                 yyleng = yylastch-yytext+1;
  2506.                 yytext[yyleng] = 0;
  2507. # ifdef LEXDEBUG
  2508.                 if(debug){
  2509.                     fprintf(yyout,"\nmatch ");
  2510.                     sprint(yytext);
  2511.                     fprintf(yyout," action %d\n",*yyfnd);
  2512.                     }
  2513. # endif
  2514.                 return(*yyfnd++);
  2515.                 }
  2516.             unput(*yylastch);
  2517.             }
  2518.         if (yytext[0] == 0  /* && feof(yyin) */)
  2519.             {
  2520.             yysptr=yysbuf;
  2521.             return(0);
  2522.             }
  2523.         yyprevious = yytext[0] = input();
  2524.         if (yyprevious>0)
  2525.             output(yyprevious);
  2526.         yylastch=yytext;
  2527. # ifdef LEXDEBUG
  2528.         if(debug)putchar('\n');
  2529. # endif
  2530.         }
  2531.     }
  2532. yyback(p, m)
  2533.     int *p;
  2534. {
  2535. if (p==0) return(0);
  2536. while (*p)
  2537.     {
  2538.     if (*p++ == m)
  2539.         return(1);
  2540.     }
  2541. return(0);
  2542. }
  2543.     /* the following are only used in the lex library */
  2544. yyinput(){
  2545.     return(input());
  2546.     }
  2547. yyoutput(c)
  2548.   int c; {
  2549.     output(c);
  2550.     }
  2551. yyunput(c)
  2552.    int c; {
  2553.     unput(c);
  2554.     }
  2555. SHAR_EOF
  2556. cat << \SHAR_EOF > cdecl.notes
  2557.  
  2558. Here is a newer version of CDecl that supports ANSI C and C++, just in time for
  2559. those who owned Lattice's C++ ... ( I don't have it myself.. ).
  2560.  
  2561. cdgram.y and cdlex.l were generated from SunOS 3.4 yacc and lex.
  2562. I kept the original cdecl.c as cdecl.old.c because I wasn't sure I didn't spoil
  2563. any of the #ifdef's or #ifndef's.
  2564.  
  2565. The file makefile.old is the old UNIX makefile. The file cdgram.old.c is the
  2566. original output from yacc. cdgram.c is the same as cdgram.old.c without the
  2567. #line directives because It has caused me problems with sdb.
  2568.  
  2569. The code was compiled under Manx C 3.6a using the portability mode ( large code,
  2570. large data, 32 bit ints ).
  2571.  
  2572.  
  2573.  
  2574. Udi Finkelstein
  2575.  
  2576. 10 Glitzenstein st.
  2577. Tel Aviv 64686 Israel
  2578. Phone: 972-3-263-927
  2579.  
  2580. BITNET:     finkel@taurus.BITNET                     ( Best )
  2581. UUCP:       ...!uunet!ulysses!attibr!althea!finkel   ( Try avoiding this )
  2582. ARPA:       finkel%taurus@cunyvm.cuny.edu            ( Same as BITNET )
  2583. FIDO:       Udi Finkelstein ( At 2:40/117 or 2:40/135
  2584.                               If you can get there at all!)
  2585. SHAR_EOF
  2586. #    End of shell archive
  2587. exit 0
  2588. -- 
  2589. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  2590. Have five nice days.
  2591.